//
// MIT License
// 
// Copyright (c) 2024 Huang Qinjin (huangqinjin@gmail.com)
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
#define _EXCLUDE_MBSTRING_CONST_CORRECT_OVERLOADS
#define _CRT_NO_INLINE_DEPRECATED_WCSTOK
#include <corecrt_internal.h>

namespace __crt_state_management
{
    static inline void enter_os_call_inline()
    {
        __acrt_FlsSetValue(__crt_global_state_mode_flsindex, (PVOID)(ULONG_PTR)1);
    }

    static inline void leave_os_call_inline()
    {
        __acrt_FlsSetValue(__crt_global_state_mode_flsindex, (PVOID)(ULONG_PTR)0);
    }

    void enter_os_call()
    {
        return enter_os_call_inline();
    }

    void leave_os_call()
    {
        return leave_os_call_inline();
    }
}

// Generate twin functions (prefixed with _o_)
// https://learn.microsoft.com/en-us/cpp/c-runtime-library/global-state

template<typename F, F f>
struct wrapped_invoker;

template<typename R, typename ...Args, R (*f)(Args...)>
struct wrapped_invoker<R (*)(Args...), f>
{
    static R call(Args... args) { return f(args...); }
};

#ifdef __cpp_noexcept_function_type
template<typename R, typename ...Args, R (*f)(Args...) noexcept>
struct wrapped_invoker<R (*)(Args...) noexcept, f>
{
    static R call(Args... args) noexcept { return f(args...); }
};
#endif

#define WRAP(f) template struct wrapped_invoker<decltype(&f), &f>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <wchar.h>
#include <uchar.h>
#include <signal.h>
#include <locale.h>
#include <float.h>

#include <mbctype.h>
#include <mbstring.h>
#include <new.h>
#include <conio.h>
#include <io.h>
#include <direct.h>

#include <sys/types.h>
#include <sys/timeb.h>
#include <sys/utime.h>

#include <corecrt_math.h>
#include <corecrt_terminate.h>
#include <corecrt_internal_stdio.h>

extern "C"
{
    void __cdecl __std_exception_copy(struct __std_exception_data const*, struct __std_exception_data*);
    void __cdecl __std_exception_destroy(struct __std_exception_data*);
    void __cdecl __std_type_info_destroy_list(struct __type_info_node*);
    const char* __cdecl __std_type_info_name(struct __std_type_info_data*, struct __type_info_node*);
    void __cdecl _except1(int, int, double, double, unsigned __int64);
}

WRAP(_Getdays);
WRAP(_Getmonths);
WRAP(_Gettnames);
WRAP(_Strftime);
WRAP(_W_Getdays);
WRAP(_W_Getmonths);
WRAP(_W_Gettnames);
WRAP(_Wcsftime);
WRAP(___lc_codepage_func);
WRAP(___lc_collate_cp_func);
WRAP(___lc_locale_name_func);
WRAP(___mb_cur_max_func);
WRAP(__acrt_iob_func);
WRAP(__conio_common_vcprintf);
WRAP(__conio_common_vcprintf_p);
WRAP(__conio_common_vcprintf_s);
WRAP(__conio_common_vcscanf);
WRAP(__conio_common_vcwprintf);
WRAP(__conio_common_vcwprintf_p);
WRAP(__conio_common_vcwprintf_s);
WRAP(__conio_common_vcwscanf);
WRAP(__daylight);
WRAP(__dstbias);
WRAP(__fpe_flt_rounds);
WRAP(__p___argc);
WRAP(__p___argv);
WRAP(__p___wargv);
WRAP(__p__acmdln);
WRAP(__p__commode);
WRAP(__p__environ);
WRAP(__p__fmode);
WRAP(__p__mbcasemap);
WRAP(__p__mbctype);
WRAP(__p__pgmptr);
WRAP(__p__wcmdln);
WRAP(__p__wenviron);
WRAP(__p__wpgmptr);
WRAP(__pctype_func);
WRAP(__pwctype_func);
WRAP(__std_exception_copy);
WRAP(__std_exception_destroy);
WRAP(__std_type_info_destroy_list);
WRAP(__std_type_info_name);
WRAP(__stdio_common_vfprintf);
WRAP(__stdio_common_vfprintf_p);
WRAP(__stdio_common_vfprintf_s);
WRAP(__stdio_common_vfscanf);
WRAP(__stdio_common_vfwprintf);
WRAP(__stdio_common_vfwprintf_p);
WRAP(__stdio_common_vfwprintf_s);
WRAP(__stdio_common_vfwscanf);
WRAP(__stdio_common_vsnprintf_s);
WRAP(__stdio_common_vsnwprintf_s);
WRAP(__stdio_common_vsprintf);
WRAP(__stdio_common_vsprintf_p);
WRAP(__stdio_common_vsprintf_s);
WRAP(__stdio_common_vsscanf);
WRAP(__stdio_common_vswprintf);
WRAP(__stdio_common_vswprintf_p);
WRAP(__stdio_common_vswprintf_s);
WRAP(__stdio_common_vswscanf);
WRAP(__timezone);
WRAP(__tzname);
WRAP(__wcserror);
WRAP(_access);
WRAP(_access_s);
WRAP(_aligned_free);
WRAP(_aligned_malloc);
WRAP(_aligned_msize);
WRAP(_aligned_offset_malloc);
WRAP(_aligned_offset_realloc);
WRAP(_aligned_offset_recalloc);
WRAP(_aligned_realloc);
WRAP(_aligned_recalloc);
WRAP(_atodbl);
WRAP(_atodbl_l);
WRAP(_atof_l);
WRAP(_atoflt);
WRAP(_atoflt_l);
WRAP(_atoi64);
WRAP(_atoi64_l);
WRAP(_atoi_l);
WRAP(_atol_l);
WRAP(_atoldbl);
WRAP(_atoldbl_l);
WRAP(_atoll_l);
WRAP(_beep);
WRAP(_beginthread);
WRAP(_beginthreadex);
WRAP(_cabs);
WRAP(_callnewh);
WRAP(_calloc_base);
WRAP(_cexit);
WRAP(_cgets);
WRAP(_cgets_s);
WRAP(_cgetws);
WRAP(_cgetws_s);
WRAP(_chdir);
WRAP(_chdrive);
WRAP(_chmod);
WRAP(_chsize);
WRAP(_chsize_s);
WRAP(_close);
WRAP(_commit);
WRAP(_configthreadlocale);
WRAP(_configure_narrow_argv);
WRAP(_configure_wide_argv);
WRAP(_controlfp_s);
WRAP(_cputs);
WRAP(_cputws);
WRAP(_creat);
WRAP(_create_locale);
WRAP(_crt_atexit);
WRAP(_ctime32_s);
WRAP(_ctime64_s);
WRAP(_cwait);
WRAP(_d_int);
WRAP(_dclass);
WRAP(_difftime32);
WRAP(_difftime64);
WRAP(_dlog);
WRAP(_dnorm);
WRAP(_dpcomp);
WRAP(_dpoly);
WRAP(_dscale);
WRAP(_dsign);
WRAP(_dsin);
WRAP(_dtest);
WRAP(_dunscale);
WRAP(_dup);
WRAP(_dup2);
WRAP(_dupenv_s);
WRAP(_ecvt);
WRAP(_ecvt_s);
WRAP(_endthread);
WRAP(_endthreadex);
WRAP(_eof);
WRAP(_errno);
WRAP(_except1);
WRAP(_execute_onexit_table);
WRAP(_execv);
WRAP(_execve);
WRAP(_execvp);
WRAP(_execvpe);
WRAP(_exit);
WRAP(_expand);
WRAP(_fclose_nolock);
WRAP(_fcloseall);
WRAP(_fcvt);
WRAP(_fcvt_s);
WRAP(_fd_int);
WRAP(_fdclass);
WRAP(_fdexp);
WRAP(_fdlog);
WRAP(_fdopen);
WRAP(_fdpcomp);
WRAP(_fdpoly);
WRAP(_fdscale);
WRAP(_fdsign);
WRAP(_fdsin);
WRAP(_fflush_nolock);
WRAP(_fgetc_nolock);
WRAP(_fgetchar);
WRAP(_fgetwc_nolock);
WRAP(_fgetwchar);
WRAP(_filelength);
WRAP(_filelengthi64);
WRAP(_fileno);
WRAP(_findclose);
WRAP(_findfirst32);
WRAP(_findfirst32i64);
WRAP(_findfirst64);
WRAP(_findfirst64i32);
WRAP(_findnext32);
WRAP(_findnext32i64);
WRAP(_findnext64);
WRAP(_findnext64i32);
WRAP(_flushall);
WRAP(_fpclass);
WRAP(_fpclassf);
WRAP(_fputc_nolock);
WRAP(_fputchar);
WRAP(_fputwc_nolock);
WRAP(_fputwchar);
WRAP(_fread_nolock);
WRAP(_fread_nolock_s);
WRAP(_free_base);
WRAP(_free_locale);
WRAP(_fseek_nolock);
WRAP(_fseeki64);
WRAP(_fseeki64_nolock);
WRAP(_fsopen);
WRAP(_fstat32);
WRAP(_fstat32i64);
WRAP(_fstat64);
WRAP(_fstat64i32);
WRAP(_ftell_nolock);
WRAP(_ftelli64);
WRAP(_ftelli64_nolock);
WRAP(_ftime32);
WRAP(_ftime32_s);
WRAP(_ftime64);
WRAP(_ftime64_s);
WRAP(_fullpath);
WRAP(_futime32);
WRAP(_futime64);
WRAP(_fwrite_nolock);
WRAP(_gcvt);
WRAP(_gcvt_s);
WRAP(_get_daylight);
WRAP(_get_doserrno);
WRAP(_get_dstbias);
WRAP(_get_errno);
WRAP(_get_fmode);
WRAP(_get_heap_handle);
WRAP(_get_initial_narrow_environment);
WRAP(_get_initial_wide_environment);
WRAP(_get_invalid_parameter_handler);
WRAP(_get_narrow_winmain_command_line);
WRAP(_get_osfhandle);
WRAP(_get_pgmptr);
WRAP(_get_stream_buffer_pointers);
WRAP(_get_terminate);
WRAP(_get_thread_local_invalid_parameter_handler);
WRAP(_get_timezone);
WRAP(_get_tzname);
WRAP(_get_wide_winmain_command_line);
WRAP(_get_wpgmptr);
WRAP(_getc_nolock);
WRAP(_getch);
WRAP(_getch_nolock);
WRAP(_getche);
WRAP(_getche_nolock);
WRAP(_getcwd);
WRAP(_getdcwd);
WRAP(_getdiskfree);
WRAP(_getdllprocaddr);
WRAP(_getdrive);
WRAP(_getdrives);
WRAP(_getmbcp);
WRAP(_getsystime);
WRAP(_getw);
WRAP(_getwc_nolock);
WRAP(_getwch);
WRAP(_getwch_nolock);
WRAP(_getwche);
WRAP(_getwche_nolock);
WRAP(_getws);
WRAP(_getws_s);
WRAP(_gmtime32);
WRAP(_gmtime32_s);
WRAP(_gmtime64);
WRAP(_gmtime64_s);
WRAP(_heapchk);
WRAP(_heapmin);
WRAP(_hypot);
WRAP(_hypotf);
WRAP(_i64toa);
WRAP(_i64toa_s);
WRAP(_i64tow);
WRAP(_i64tow_s);
WRAP(_initialize_narrow_environment);
WRAP(_initialize_onexit_table);
WRAP(_initialize_wide_environment);
WRAP(_invalid_parameter_noinfo);
WRAP(_invalid_parameter_noinfo_noreturn);
WRAP(_isatty);
WRAP(_isctype);
WRAP(_isctype_l);
WRAP(_isleadbyte_l);
WRAP(_ismbbalnum);
WRAP(_ismbbalnum_l);
WRAP(_ismbbalpha);
WRAP(_ismbbalpha_l);
WRAP(_ismbbblank);
WRAP(_ismbbblank_l);
WRAP(_ismbbgraph);
WRAP(_ismbbgraph_l);
WRAP(_ismbbkalnum);
WRAP(_ismbbkalnum_l);
WRAP(_ismbbkana);
WRAP(_ismbbkana_l);
WRAP(_ismbbkprint);
WRAP(_ismbbkprint_l);
WRAP(_ismbbkpunct);
WRAP(_ismbbkpunct_l);
WRAP(_ismbblead);
WRAP(_ismbblead_l);
WRAP(_ismbbprint);
WRAP(_ismbbprint_l);
WRAP(_ismbbpunct);
WRAP(_ismbbpunct_l);
WRAP(_ismbbtrail);
WRAP(_ismbbtrail_l);
WRAP(_ismbcalnum);
WRAP(_ismbcalnum_l);
WRAP(_ismbcalpha);
WRAP(_ismbcalpha_l);
WRAP(_ismbcblank);
WRAP(_ismbcblank_l);
WRAP(_ismbcdigit);
WRAP(_ismbcdigit_l);
WRAP(_ismbcgraph);
WRAP(_ismbcgraph_l);
WRAP(_ismbchira);
WRAP(_ismbchira_l);
WRAP(_ismbckata);
WRAP(_ismbckata_l);
WRAP(_ismbcl0);
WRAP(_ismbcl0_l);
WRAP(_ismbcl1);
WRAP(_ismbcl1_l);
WRAP(_ismbcl2);
WRAP(_ismbcl2_l);
WRAP(_ismbclegal);
WRAP(_ismbclegal_l);
WRAP(_ismbclower);
WRAP(_ismbclower_l);
WRAP(_ismbcprint);
WRAP(_ismbcprint_l);
WRAP(_ismbcpunct);
WRAP(_ismbcpunct_l);
WRAP(_ismbcspace);
WRAP(_ismbcspace_l);
WRAP(_ismbcsymbol);
WRAP(_ismbcsymbol_l);
WRAP(_ismbcupper);
WRAP(_ismbcupper_l);
WRAP(_ismbslead);
WRAP(_ismbslead_l);
WRAP(_ismbstrail);
WRAP(_ismbstrail_l);
WRAP(_iswctype_l);
WRAP(_itoa);
WRAP(_itoa_s);
WRAP(_itow);
WRAP(_itow_s);
WRAP(_j0);
WRAP(_j1);
WRAP(_jn);
WRAP(_kbhit);
WRAP(_ld_int);
WRAP(_ldclass);
WRAP(_ldexp);
WRAP(_ldlog);
WRAP(_ldpcomp);
WRAP(_ldpoly);
WRAP(_ldscale);
WRAP(_ldsign);
WRAP(_ldsin);
WRAP(_ldtest);
WRAP(_ldunscale);
WRAP(_lfind);
WRAP(_lfind_s);
WRAP(_loaddll);
WRAP(_localtime32);
WRAP(_localtime32_s);
WRAP(_localtime64);
WRAP(_localtime64_s);
WRAP(_lock_file);
WRAP(_locking);
WRAP(_logb);
WRAP(_logbf);
WRAP(_lsearch);
WRAP(_lsearch_s);
WRAP(_lseek);
WRAP(_lseeki64);
WRAP(_ltoa);
WRAP(_ltoa_s);
WRAP(_ltow);
WRAP(_ltow_s);
WRAP(_makepath);
WRAP(_makepath_s);
WRAP(_malloc_base);
WRAP(_mbbtombc);
WRAP(_mbbtombc_l);
WRAP(_mbbtype);
WRAP(_mbbtype_l);
WRAP(_mbccpy);
WRAP(_mbccpy_l);
WRAP(_mbccpy_s);
WRAP(_mbccpy_s_l);
WRAP(_mbcjistojms);
WRAP(_mbcjistojms_l);
WRAP(_mbcjmstojis);
WRAP(_mbcjmstojis_l);
WRAP(_mbclen);
WRAP(_mbclen_l);
WRAP(_mbctohira);
WRAP(_mbctohira_l);
WRAP(_mbctokata);
WRAP(_mbctokata_l);
WRAP(_mbctolower);
WRAP(_mbctolower_l);
WRAP(_mbctombb);
WRAP(_mbctombb_l);
WRAP(_mbctoupper);
WRAP(_mbctoupper_l);
WRAP(_mblen_l);
WRAP(_mbsbtype);
WRAP(_mbsbtype_l);
WRAP(_mbscat_s);
WRAP(_mbscat_s_l);
WRAP(_mbschr);
WRAP(_mbschr_l);
WRAP(_mbscmp);
WRAP(_mbscmp_l);
WRAP(_mbscoll);
WRAP(_mbscoll_l);
WRAP(_mbscpy_s);
WRAP(_mbscpy_s_l);
WRAP(_mbscspn);
WRAP(_mbscspn_l);
WRAP(_mbsdec);
WRAP(_mbsdec_l);
WRAP(_mbsicmp);
WRAP(_mbsicmp_l);
WRAP(_mbsicoll);
WRAP(_mbsicoll_l);
WRAP(_mbsinc);
WRAP(_mbsinc_l);
WRAP(_mbslen);
WRAP(_mbslen_l);
WRAP(_mbslwr);
WRAP(_mbslwr_l);
WRAP(_mbslwr_s);
WRAP(_mbslwr_s_l);
WRAP(_mbsnbcat);
WRAP(_mbsnbcat_l);
WRAP(_mbsnbcat_s);
WRAP(_mbsnbcat_s_l);
WRAP(_mbsnbcmp);
WRAP(_mbsnbcmp_l);
WRAP(_mbsnbcnt);
WRAP(_mbsnbcnt_l);
WRAP(_mbsnbcoll);
WRAP(_mbsnbcoll_l);
WRAP(_mbsnbcpy);
WRAP(_mbsnbcpy_l);
WRAP(_mbsnbcpy_s);
WRAP(_mbsnbcpy_s_l);
WRAP(_mbsnbicmp);
WRAP(_mbsnbicmp_l);
WRAP(_mbsnbicoll);
WRAP(_mbsnbicoll_l);
WRAP(_mbsnbset);
WRAP(_mbsnbset_l);
WRAP(_mbsnbset_s);
WRAP(_mbsnbset_s_l);
WRAP(_mbsncat);
WRAP(_mbsncat_l);
WRAP(_mbsncat_s);
WRAP(_mbsncat_s_l);
WRAP(_mbsnccnt);
WRAP(_mbsnccnt_l);
WRAP(_mbsncmp);
WRAP(_mbsncmp_l);
WRAP(_mbsncoll);
WRAP(_mbsncoll_l);
WRAP(_mbsncpy);
WRAP(_mbsncpy_l);
WRAP(_mbsncpy_s);
WRAP(_mbsncpy_s_l);
WRAP(_mbsnextc);
WRAP(_mbsnextc_l);
WRAP(_mbsnicmp);
WRAP(_mbsnicmp_l);
WRAP(_mbsnicoll);
WRAP(_mbsnicoll_l);
WRAP(_mbsninc);
WRAP(_mbsninc_l);
WRAP(_mbsnlen);
WRAP(_mbsnlen_l);
WRAP(_mbsnset);
WRAP(_mbsnset_l);
WRAP(_mbsnset_s);
WRAP(_mbsnset_s_l);
WRAP(_mbspbrk);
WRAP(_mbspbrk_l);
WRAP(_mbsrchr);
WRAP(_mbsrchr_l);
WRAP(_mbsrev);
WRAP(_mbsrev_l);
WRAP(_mbsset);
WRAP(_mbsset_l);
WRAP(_mbsset_s);
WRAP(_mbsset_s_l);
WRAP(_mbsspn);
WRAP(_mbsspn_l);
WRAP(_mbsspnp);
WRAP(_mbsspnp_l);
WRAP(_mbsstr);
WRAP(_mbsstr_l);
WRAP(_mbstok);
WRAP(_mbstok_l);
WRAP(_mbstok_s);
WRAP(_mbstok_s_l);
WRAP(_mbstowcs_l);
WRAP(_mbstowcs_s_l);
WRAP(_mbstrlen);
WRAP(_mbstrlen_l);
WRAP(_mbstrnlen);
WRAP(_mbstrnlen_l);
WRAP(_mbsupr);
WRAP(_mbsupr_l);
WRAP(_mbsupr_s);
WRAP(_mbsupr_s_l);
WRAP(_mbtowc_l);
WRAP(_memicmp);
WRAP(_memicmp_l);
WRAP(_mkdir);
WRAP(_mkgmtime32);
WRAP(_mkgmtime64);
WRAP(_mktemp);
WRAP(_mktemp_s);
WRAP(_mktime32);
WRAP(_mktime64);
WRAP(_msize);
WRAP(_nextafter);
WRAP(_nextafterf);
WRAP(_open_osfhandle);
WRAP(_pclose);
WRAP(_pipe);
WRAP(_popen);
WRAP(_purecall);
WRAP(_putc_nolock);
WRAP(_putch);
WRAP(_putch_nolock);
WRAP(_putenv);
WRAP(_putenv_s);
WRAP(_putw);
WRAP(_putwc_nolock);
WRAP(_putwch);
WRAP(_putwch_nolock);
WRAP(_putws);
WRAP(_read);
WRAP(_realloc_base);
WRAP(_recalloc);
WRAP(_register_onexit_function);
WRAP(_resetstkoflw);
WRAP(_rmdir);
WRAP(_rmtmp);
WRAP(_scalb);
WRAP(_scalbf);
WRAP(_searchenv);
WRAP(_searchenv_s);
WRAP(_seh_filter_dll);
WRAP(_seh_filter_exe);
WRAP(_set_abort_behavior);
WRAP(_set_app_type);
WRAP(_set_doserrno);
WRAP(_set_errno);
WRAP(_set_fmode);
WRAP(_set_invalid_parameter_handler);
WRAP(_set_new_handler);
WRAP(_set_new_mode);
WRAP(_set_thread_local_invalid_parameter_handler);
WRAP(_seterrormode);
WRAP(_setmbcp);
WRAP(_setmode);
WRAP(_setsystime);
WRAP(_sleep);
WRAP(_sopen);
WRAP(_sopen_dispatch);
WRAP(_sopen_s);
WRAP(_spawnv);
WRAP(_spawnve);
WRAP(_spawnvp);
WRAP(_spawnvpe);
WRAP(_splitpath);
WRAP(_splitpath_s);
WRAP(_stat32);
WRAP(_stat32i64);
WRAP(_stat64);
WRAP(_stat64i32);
WRAP(_strcoll_l);
WRAP(_strdate);
WRAP(_strdate_s);
WRAP(_strdup);
WRAP(_strerror);
WRAP(_strerror_s);
WRAP(_strftime_l);
WRAP(_stricmp);
WRAP(_stricmp_l);
WRAP(_stricoll);
WRAP(_stricoll_l);
WRAP(_strlwr);
WRAP(_strlwr_l);
WRAP(_strlwr_s);
WRAP(_strlwr_s_l);
WRAP(_strncoll);
WRAP(_strncoll_l);
WRAP(_strnicmp);
WRAP(_strnicmp_l);
WRAP(_strnicoll);
WRAP(_strnicoll_l);
WRAP(_strnset_s);
WRAP(_strset_s);
WRAP(_strtime);
WRAP(_strtime_s);
WRAP(_strtod_l);
WRAP(_strtof_l);
WRAP(_strtoi64);
WRAP(_strtoi64_l);
WRAP(_strtol_l);
WRAP(_strtold_l);
WRAP(_strtoll_l);
WRAP(_strtoui64);
WRAP(_strtoui64_l);
WRAP(_strtoul_l);
WRAP(_strtoull_l);
WRAP(_strupr);
WRAP(_strupr_l);
WRAP(_strupr_s);
WRAP(_strupr_s_l);
WRAP(_strxfrm_l);
WRAP(_swab);
WRAP(_tell);
WRAP(_telli64);
WRAP(_timespec32_get);
WRAP(_timespec64_get);
WRAP(_tolower);
WRAP(_tolower_l);
WRAP(_toupper);
WRAP(_toupper_l);
WRAP(_towlower_l);
WRAP(_towupper_l);
WRAP(_tzset);
WRAP(_ui64toa);
WRAP(_ui64toa_s);
WRAP(_ui64tow);
WRAP(_ui64tow_s);
WRAP(_ultoa);
WRAP(_ultoa_s);
WRAP(_ultow);
WRAP(_ultow_s);
WRAP(_umask);
WRAP(_umask_s);
WRAP(_ungetc_nolock);
WRAP(_ungetch);
WRAP(_ungetch_nolock);
WRAP(_ungetwc_nolock);
WRAP(_ungetwch);
WRAP(_ungetwch_nolock);
WRAP(_unlink);
WRAP(_unloaddll);
WRAP(_unlock_file);
WRAP(_utime32);
WRAP(_utime64);
WRAP(_waccess);
WRAP(_waccess_s);
WRAP(_wasctime);
WRAP(_wasctime_s);
WRAP(_wchdir);
WRAP(_wchmod);
WRAP(_wcreat);
WRAP(_wcreate_locale);
WRAP(_wcscoll_l);
WRAP(_wcsdup);
WRAP(_wcserror);
WRAP(_wcserror_s);
WRAP(_wcsftime_l);
WRAP(_wcsicmp);
WRAP(_wcsicmp_l);
WRAP(_wcsicoll);
WRAP(_wcsicoll_l);
WRAP(_wcslwr);
WRAP(_wcslwr_l);
WRAP(_wcslwr_s);
WRAP(_wcslwr_s_l);
WRAP(_wcsncoll);
WRAP(_wcsncoll_l);
WRAP(_wcsnicmp);
WRAP(_wcsnicmp_l);
WRAP(_wcsnicoll);
WRAP(_wcsnicoll_l);
WRAP(_wcsnset);
WRAP(_wcsnset_s);
WRAP(_wcsset);
WRAP(_wcsset_s);
WRAP(_wcstod_l);
WRAP(_wcstof_l);
WRAP(_wcstoi64);
WRAP(_wcstoi64_l);
WRAP(_wcstol_l);
WRAP(_wcstold_l);
WRAP(_wcstoll_l);
WRAP(_wcstombs_l);
WRAP(_wcstombs_s_l);
WRAP(_wcstoui64);
WRAP(_wcstoui64_l);
WRAP(_wcstoul_l);
WRAP(_wcstoull_l);
WRAP(_wcsupr);
WRAP(_wcsupr_l);
WRAP(_wcsupr_s);
WRAP(_wcsupr_s_l);
WRAP(_wcsxfrm_l);
WRAP(_wctime32);
WRAP(_wctime32_s);
WRAP(_wctime64);
WRAP(_wctime64_s);
WRAP(_wctomb_l);
WRAP(_wctomb_s_l);
WRAP(_wdupenv_s);
WRAP(_wexecv);
WRAP(_wexecve);
WRAP(_wexecvp);
WRAP(_wexecvpe);
WRAP(_wfdopen);
WRAP(_wfindfirst32);
WRAP(_wfindfirst32i64);
WRAP(_wfindfirst64);
WRAP(_wfindfirst64i32);
WRAP(_wfindnext32);
WRAP(_wfindnext32i64);
WRAP(_wfindnext64);
WRAP(_wfindnext64i32);
WRAP(_wfopen);
WRAP(_wfopen_s);
WRAP(_wfreopen);
WRAP(_wfreopen_s);
WRAP(_wfsopen);
WRAP(_wfullpath);
WRAP(_wgetcwd);
WRAP(_wgetdcwd);
WRAP(_wgetenv);
WRAP(_wgetenv_s);
WRAP(_wmakepath);
WRAP(_wmakepath_s);
WRAP(_wmkdir);
WRAP(_wmktemp);
WRAP(_wmktemp_s);
WRAP(_wperror);
WRAP(_wpopen);
WRAP(_wputenv);
WRAP(_wputenv_s);
WRAP(_wremove);
WRAP(_wrename);
WRAP(_write);
WRAP(_wrmdir);
WRAP(_wsearchenv);
WRAP(_wsearchenv_s);
WRAP(_wsetlocale);
WRAP(_wsopen_dispatch);
WRAP(_wsopen_s);
WRAP(_wspawnv);
WRAP(_wspawnve);
WRAP(_wspawnvp);
WRAP(_wspawnvpe);
WRAP(_wsplitpath);
WRAP(_wsplitpath_s);
WRAP(_wstat32);
WRAP(_wstat32i64);
WRAP(_wstat64);
WRAP(_wstat64i32);
WRAP(_wstrdate);
WRAP(_wstrdate_s);
WRAP(_wstrtime);
WRAP(_wstrtime_s);
WRAP(_wsystem);
WRAP(_wtmpnam_s);
WRAP(_wtof);
WRAP(_wtof_l);
WRAP(_wtoi);
WRAP(_wtoi64);
WRAP(_wtoi64_l);
WRAP(_wtoi_l);
WRAP(_wtol);
WRAP(_wtol_l);
WRAP(_wtoll);
WRAP(_wtoll_l);
WRAP(_wunlink);
WRAP(_wutime32);
WRAP(_wutime64);
WRAP(_y0);
WRAP(_y1);
WRAP(_yn);
WRAP(abort);
WRAP(acos);
WRAP(acosf);
WRAP(acosh);
WRAP(acoshf);
WRAP(acoshl);
WRAP(asctime);
WRAP(asctime_s);
WRAP(asin);
WRAP(asinf);
WRAP(asinh);
WRAP(asinhf);
WRAP(asinhl);
WRAP(atan);
WRAP(atan2);
WRAP(atan2f);
WRAP(atanf);
WRAP(atanh);
WRAP(atanhf);
WRAP(atanhl);
WRAP(atof);
WRAP(atoi);
WRAP(atol);
WRAP(atoll);
WRAP(bsearch);
WRAP(bsearch_s);
WRAP(btowc);
WRAP(calloc);
WRAP(cbrt);
WRAP(cbrtf);
WRAP(ceil);
WRAP(ceilf);
WRAP(clearerr);
WRAP(clearerr_s);
WRAP(cos);
WRAP(cosf);
WRAP(cosh);
WRAP(coshf);
WRAP(erf);
WRAP(erfc);
WRAP(erfcf);
WRAP(erfcl);
WRAP(erff);
WRAP(erfl);
WRAP(exit);
WRAP(exp);
WRAP(exp2);
WRAP(exp2f);
WRAP(exp2l);
WRAP(expf);
WRAP(fabs);
WRAP(fclose);
WRAP(feof);
WRAP(ferror);
WRAP(fflush);
WRAP(fgetc);
WRAP(fgetpos);
WRAP(fgets);
WRAP(fgetwc);
WRAP(fgetws);
WRAP(floor);
WRAP(floorf);
WRAP(fma);
WRAP(fmaf);
WRAP(fmal);
WRAP(fmod);
WRAP(fmodf);
WRAP(fopen);
WRAP(fopen_s);
WRAP(fputc);
WRAP(fputs);
WRAP(fputwc);
WRAP(fputws);
WRAP(fread);
WRAP(fread_s);
WRAP(free);
WRAP(freopen);
WRAP(freopen_s);
WRAP(frexp);
WRAP(fseek);
WRAP(fsetpos);
WRAP(ftell);
WRAP(fwrite);
WRAP(getc);
WRAP(getchar);
WRAP(getenv);
WRAP(getenv_s);
WRAP(gets);
WRAP(gets_s);
WRAP(getwc);
WRAP(getwchar);
WRAP(hypot);
WRAP(is_wctype);
WRAP(isalnum);
WRAP(isalpha);
WRAP(isblank);
WRAP(iscntrl);
WRAP(isdigit);
WRAP(isgraph);
WRAP(isleadbyte);
WRAP(islower);
WRAP(isprint);
WRAP(ispunct);
WRAP(isspace);
WRAP(isupper);
WRAP(iswalnum);
WRAP(iswalpha);
WRAP(iswascii);
WRAP(iswblank);
WRAP(iswcntrl);
WRAP(iswctype);
WRAP(iswdigit);
WRAP(iswgraph);
WRAP(iswlower);
WRAP(iswprint);
WRAP(iswpunct);
WRAP(iswspace);
WRAP(iswupper);
WRAP(iswxdigit);
WRAP(isxdigit);
WRAP(ldexp);
WRAP(lgamma);
WRAP(lgammaf);
WRAP(lgammal);
WRAP(llrint);
WRAP(llrintf);
WRAP(llrintl);
WRAP(llround);
WRAP(llroundf);
WRAP(llroundl);
WRAP(localeconv);
WRAP(log);
WRAP(log10);
WRAP(log10f);
WRAP(log1p);
WRAP(log1pf);
WRAP(log1pl);
WRAP(log2);
WRAP(log2f);
WRAP(log2l);
WRAP(logb);
WRAP(logbf);
WRAP(logbl);
WRAP(logf);
WRAP(lrint);
WRAP(lrintf);
WRAP(lrintl);
WRAP(lround);
WRAP(lroundf);
WRAP(lroundl);
WRAP(malloc);
WRAP(mblen);
WRAP(mbrlen);
WRAP(mbrtoc16);
WRAP(mbrtoc32);
WRAP(mbrtowc);
WRAP(mbsrtowcs);
WRAP(mbsrtowcs_s);
WRAP(mbstowcs);
WRAP(mbstowcs_s);
WRAP(mbtowc);
WRAP(memcpy_s);
WRAP(memset);
WRAP(modf);
WRAP(modff);
WRAP(nan);
WRAP(nanf);
WRAP(nanl);
WRAP(nearbyint);
WRAP(nearbyintf);
WRAP(nearbyintl);
WRAP(nextafter);
WRAP(nextafterf);
WRAP(nextafterl);
WRAP(nexttoward);
WRAP(nexttowardf);
WRAP(nexttowardl);
WRAP(pow);
WRAP(powf);
WRAP(putc);
WRAP(putchar);
WRAP(puts);
WRAP(putwc);
WRAP(putwchar);
WRAP(qsort);
WRAP(qsort_s);
WRAP(raise);
WRAP(rand);
WRAP(rand_s);
WRAP(realloc);
WRAP(remainder);
WRAP(remainderf);
WRAP(remainderl);
WRAP(remove);
WRAP(remquo);
WRAP(remquof);
WRAP(remquol);
WRAP(rename);
WRAP(rewind);
WRAP(rint);
WRAP(rintf);
WRAP(rintl);
WRAP(round);
WRAP(roundf);
WRAP(roundl);
WRAP(scalbln);
WRAP(scalblnf);
WRAP(scalblnl);
WRAP(scalbn);
WRAP(scalbnf);
WRAP(scalbnl);
WRAP(set_terminate);
WRAP(setbuf);
WRAP(setlocale);
WRAP(setvbuf);
WRAP(sin);
WRAP(sinf);
WRAP(sinh);
WRAP(sinhf);
WRAP(sqrt);
WRAP(sqrtf);
WRAP(srand);
WRAP(strcat_s);
WRAP(strcoll);
WRAP(strcpy_s);
WRAP(strerror);
WRAP(strerror_s);
WRAP(strftime);
WRAP(strncat_s);
WRAP(strncpy_s);
WRAP(strtod);
WRAP(strtof);
WRAP(strtok);
WRAP(strtok_s);
WRAP(strtol);
WRAP(strtold);
WRAP(strtoll);
WRAP(strtoul);
WRAP(strtoull);
WRAP(system);
WRAP(tan);
WRAP(tanf);
WRAP(tanh);
WRAP(tanhf);
WRAP(terminate);
WRAP(tgamma);
WRAP(tgammaf);
WRAP(tgammal);
WRAP(tmpfile_s);
WRAP(tmpnam_s);
WRAP(tolower);
WRAP(toupper);
WRAP(towlower);
WRAP(towupper);
WRAP(ungetc);
WRAP(ungetwc);
WRAP(wcrtomb);
WRAP(wcrtomb_s);
WRAP(wcscat_s);
WRAP(wcscoll);
WRAP(wcscpy);
WRAP(wcscpy_s);
WRAP(wcsftime);
WRAP(wcsncat_s);
WRAP(wcsncpy_s);
WRAP(wcsrtombs);
WRAP(wcsrtombs_s);
WRAP(wcstod);
WRAP(wcstof);
WRAP(wcstok);
WRAP(wcstok_s);
WRAP(wcstol);
WRAP(wcstold);
WRAP(wcstoll);
WRAP(wcstombs);
WRAP(wcstombs_s);
WRAP(wcstoul);
WRAP(wcstoull);
WRAP(wctob);
WRAP(wctomb);
WRAP(wctomb_s);
WRAP(wmemcpy_s);
WRAP(wmemmove_s);
